GraphQL Föderatsioon: Skeemi sidumine (Schema Stitching) - põhjalik juhend

Kaasaegse rakenduste arenduse pidevalt areneval maastikul on skaleeritavate ja hooldatavate arhitektuuride vajadus muutunud esmatähtsaks. Mikroteenused on oma olemusliku modulaarsuse ja iseseisva kasutuselevõtuga kujunenud populaarseks lahenduseks. Paljude mikroteenuste haldamine võib aga tekitada keerukusi, eriti kui on vaja pakkuda kliendirakendustele ühtset API-d. Siin tulebki mängu GraphQL Föderatsioon ja eriti skeemi sidumine (Schema Stitching).

Mis on GraphQL Föderatsioon?

GraphQL Föderatsioon on võimas arhitektuur, mis võimaldab teil luua ühe, ühtse GraphQL API mitmest aluseks olevast GraphQL teenusest (mis sageli esindavad mikroteenuseid). See võimaldab arendajatel pärida andmeid erinevatest teenustest, justkui oleks tegemist ühe graafikuga, lihtsustades kliendi kogemust ja vähendades vajadust keeruka orkestreerimisloogika järele kliendi poolel.

GraphQL Föderatsioonile on kaks peamist lähenemist:

• Skeemi sidumine (Schema Stitching): See hõlmab mitme GraphQL skeemi kombineerimist üheks, ühtseks skeemiks lüüsi kihis. See on varasem lähenemine ja tugineb teekidele, et hallata skeemide kombineerimist ja päringute delegeerimist.
• Apollo Föderatsioon: See on uuem ja robustsem lähenemine, mis kasutab föderatsiooniprotsessi haldamiseks deklaratiivset skeemikeelt ja spetsiaalset päringute planeerijat. See pakub täiustatud funktsioone nagu tüübilaiendused, võtmedirektiivid ja hajutatud jälgimine.

See artikkel keskendub skeemi sidumisele (Schema Stitching), uurides selle kontseptsioone, eeliseid, piiranguid ja praktilist rakendamist.

Skeemi sidumise mõistmine

Skeemi sidumine on mitme GraphQL skeemi liitmise protsess üheks, sidusaks skeemiks. See ühtne skeem toimib fassaadina, varjates aluseks olevate teenuste keerukuse kliendi eest. Kui klient teeb päringu seotud skeemile, suunab lüüs päringu arukalt vastavasse alusteenusesse (või teenustesse), hangib andmed ja kombineerib tulemused enne nende kliendile tagastamist.

Mõelge sellest nii: teil on mitu restorani (teenused), mis on spetsialiseerunud erinevatele köökidele. Skeemi sidumine on nagu universaalne menüü, mis koondab kõigi restoranide kõik road. Kui klient (klient) tellib universaalsest menüüst, suunatakse tellimus arukalt vastavatesse restoraniköökidesse, toit valmistatakse ja kombineeritakse seejärel üheks tarnimiseks kliendile.

Skeemi sidumise põhimõisted

• Kaug-skeemid: Need on iga aluseks oleva teenuse individuaalsed GraphQL skeemid. Iga teenus pakub oma skeemi, mis määratleb selle pakutavad andmed ja toimingud.
• Lüüs (Gateway): Lüüs on keskne komponent, mis vastutab kaug-skeemide kokku sidumise ja ühtse skeemi kliendile pakkumise eest. See võtab vastu kliendi päringuid, suunab need vastavatesse teenustesse ja kombineerib tulemused.
• Skeemide liitmine: See on kaug-skeemide kombineerimise protsess üheks skeemiks. See hõlmab sageli tüüpide ja väljade ümbernimetamist konfliktide vältimiseks ning tüüpide vaheliste seoste määratlemist erinevates skeemides.
• Päringu delegeerimine: Kui klient teeb päringu seotud skeemile, peab lüüs delegeerima päringu vastavale alusteenusele (või teenustele) andmete hankimiseks. See hõlmab kliendi päringu tõlkimist päringuks, mida kaugteenus mõistab.
• Tulemuste koondamine: Pärast seda, kui lüüs on andmed aluseks olevatest teenustest hankinud, peab ta tulemused koondama üheks vastuseks, mida saab kliendile tagastada. See hõlmab sageli andmete teisendamist, et need vastaksid seotud skeemi struktuurile.

Skeemi sidumise eelised

Skeemi sidumine pakub mitmeid kaalukaid eeliseid organisatsioonidele, kes võtavad kasutusele mikroteenuste arhitektuuri:

• Ühtne API: Pakub klientidele ühtset ja järjepidevat API-d, lihtsustades andmetele juurdepääsu ja vähendades vajadust klientidele otse mitme teenusega suhelda. Tulemuseks on puhtam ja intuitiivsem arendajakogemus.
• Vähenenud kliendipoolne keerukus: Kliendid peavad suhtlema ainult ühtse skeemiga, mis kaitseb neid aluseks oleva mikroteenuste arhitektuuri keerukuse eest. See lihtsustab kliendipoolset arendust ja vähendab kliendis vajaliku koodi hulka.
• Suurenenud skaleeritavus: Võimaldab teil skaleerida üksikuid teenuseid iseseisvalt vastavalt nende konkreetsetele vajadustele. See parandab süsteemi üldist skaleeritavust ja vastupidavust. Näiteks saab suure koormusega kasutajateenust skaleerida, mõjutamata teisi teenuseid, nagu tootekataloog.
• Parem hooldatavus: Edendab modulaarsust ja vastutusalade eraldamist, muutes üksikute teenuste hooldamise ja arendamise lihtsamaks. Muudatused ühes teenuses mõjutavad vähem tõenäoliselt teisi teenuseid.
• Järkjärguline kasutuselevõtt: Saab rakendada järk-järgult, võimaldades teil minna monoliitselt arhitektuurilt üle mikroteenuste arhitektuurile. Võite alustada olemasolevate API-de kokku sidumisega ja seejärel monoliiti järk-järgult väiksemateks teenusteks lagundada.

Skeemi sidumise piirangud

Kuigi skeemi sidumine pakub arvukalt eeliseid, on oluline olla teadlik ka selle piirangutest:

• Keerukus: Skeemi sidumise rakendamine ja haldamine võib olla keeruline, eriti suurtes ja keerukates süsteemides. Hoolikas planeerimine ja disain on hädavajalikud.
• Jõudluse lisakulu: Lüüs tekitab täiendava kaudse kihi ning päringute delegeerimise ja tulemuste koondamise vajaduse tõttu jõudluse lisakulu. Selle lisakulu minimeerimiseks on oluline hoolikas optimeerimine.
• Skeemide konfliktid: Konfliktid võivad tekkida erinevate teenuste skeemide liitmisel, eriti kui nad kasutavad samu tüübi- või väljanimesid. See nõuab hoolikat skeemi disaini ja potentsiaalselt tüüpide ja väljade ümbernimetamist.
• Piiratud täiustatud funktsioonid: Võrreldes Apollo Föderatsiooniga puuduvad skeemi sidumisel mõned täiustatud funktsioonid, nagu tüübilaiendused ja võtmedirektiivid, mis võivad muuta tüüpide vaheliste seoste haldamise erinevates skeemides keerulisemaks.
• Tööriistade küpsus: Skeemi sidumise ümber olevad tööriistad ja ökosüsteem ei ole nii küpsed kui Apollo Föderatsiooni omad. See võib muuta probleemide silumise ja tõrkeotsingu keerulisemaks.

Skeemi sidumise praktiline rakendamine

Vaatame läbi lihtsustatud näite, kuidas rakendada skeemi sidumist Node.js-i ja graphql-tools teegi (populaarne valik skeemi sidumiseks) abil. See näide hõlmab kahte mikroteenust: kasutajateenus (User Service) ja tooteteenus (Product Service).

1. Kaug-skeemide määratlemine

Kõigepealt määratlege GraphQL skeemid iga kaugteenuse jaoks.

Kasutajateenus (user-service.js):

const { buildSchema } = require('graphql');

const userSchema = buildSchema(`
  type User {
    id: ID!
    name: String
    email: String
  }

  type Query {
    user(id: ID!): User
  }
`);

const users = [
  { id: '1', name: 'Alice Smith', email: 'alice@example.com' },
  { id: '2', name: 'Bob Johnson', email: 'bob@example.com' },
];

const userRoot = {
  user: (args) => users.find(user => user.id === args.id),
};

module.exports = {
  schema: userSchema,
  rootValue: userRoot,
};

Tooteteenus (product-service.js):

const { buildSchema } = require('graphql');

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Võõrvõti kasutajateenusele
  }

  type Query {
    product(id: ID!): Product
  }
`);

const products = [
  { id: '101', name: 'Laptop', price: 1200, userId: '1' },
  { id: '102', name: 'Smartphone', price: 800, userId: '2' },
];

const productRoot = {
  product: (args) => products.find(product => product.id === args.id),
};

module.exports = {
  schema: productSchema,
  rootValue: productRoot,
};

2. Lüüsiteenuse loomine

Nüüd looge lüüsiteenus, mis seob kaks skeemi omavahel kokku.

Lüüsiteenus (gateway.js):

const { stitchSchemas } = require('@graphql-tools/stitch');
const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { graphqlHTTP } = require('express-graphql');
const express = require('express');
const { introspectSchema } = require('@graphql-tools/wrap');
const { printSchema } = require('graphql');
const fetch = require('node-fetch');

async function createRemoteSchema(uri) {
  const fetcher = async (params) => {
    const response = await fetch(uri, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params),
    });
    return response.json();
  };

  const schema = await introspectSchema(fetcher);
  return makeRemoteExecutableSchema({
    schema,
    fetcher,
  });
}

async function main() {
  const userSchema = await createRemoteSchema('http://localhost:4001/graphql');
  const productSchema = await createRemoteSchema('http://localhost:4002/graphql');

  const stitchedSchema = stitchSchemas({
    subschemas: [
      { schema: userSchema },
      { schema: productSchema },
    ],
    typeDefs: `
      extend type Product {
        user: User
      }
    `,
    resolvers: {
      Product: {
        user: {
          selectionSet: `{ userId }`,
          resolve(product, args, context, info) {
            return info.mergeInfo.delegateToSchema({
              schema: userSchema,
              operation: 'query',
              fieldName: 'user',
              args: {
                id: product.userId,
              },
              context,
              info,
            });
          },
        },
      },
    },
  });

  const app = express();
  app.use('/graphql', graphqlHTTP({
    schema: stitchedSchema,
    graphiql: true,
  }));

  app.listen(4000, () => console.log('Lüüsiserver töötab aadressil http://localhost:4000/graphql'));
}

main().catch(console.error);

3. Teenuste käivitamine

Peate käivitama kasutajateenuse ja tooteteenuse erinevatel portidel. Näiteks:

Kasutajateenus (port 4001):

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./user-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4001, () => console.log('Kasutajateenus töötab aadressil http://localhost:4001/graphql'));

Tooteteenus (port 4002):

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./product-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4002, () => console.log('Tooteteenus töötab aadressil http://localhost:4002/graphql'));

4. Seotud skeemi pärimine

Nüüd saate pärida seotud skeemi lüüsi kaudu (mis töötab pordil 4000). Saate käivitada sellise päringu:

query {
  product(id: "101") {
    id
    name
    price
    user {
      id
      name
      email
    }
  }
}

See päring hangib toote ID-ga "101" ja toob ka seotud kasutaja kasutajateenusest, demonstreerides, kuidas skeemi sidumine võimaldab teil pärida andmeid mitmest teenusest ühe päringuga.

Täiustatud skeemi sidumise tehnikad

Lisaks põhinäitele on siin mõned täiustatud tehnikad, mida saab kasutada oma skeemi sidumise rakenduse täiustamiseks:

• Skeemi delegeerimine: See võimaldab delegeerida päringu osi erinevatele teenustele vastavalt küsitavatele andmetele. Näiteks võite delegeerida User tüübi lahendamise kasutajateenusele ja Product tüübi lahendamise tooteteenusele.
• Skeemi teisendamine: See hõlmab kaugteenuse skeemi muutmist enne, kui see liidetakse ühtsesse skeemi. See võib olla kasulik tüüpide ja väljade ümbernimetamiseks, uute väljade lisamiseks või olemasolevate väljade eemaldamiseks.
• Kohandatud resolverid: Saate lüüsis määratleda kohandatud resolverid, et käsitleda keerukaid andmete teisendusi või hankida andmeid mitmest teenusest ja kombineerida need üheks tulemuseks.
• Konteksti jagamine: Sageli on vaja jagada kontekstiinfot, näiteks autentimismärke või kasutajatunnuseid, lüüsi ja kaugteenuste vahel. Seda saab saavutada, edastades kontekstiinfot osana päringu delegeerimise protsessist.
• Vigade käsitlemine: Rakendage robustne vigade käsitlemine, et graatsiliselt käsitleda vigu, mis tekivad kaugteenustes. See võib hõlmata vigade logimist, kasutajasõbralike veateadete tagastamist või ebaõnnestunud päringute uuesti proovimist.

Valik skeemi sidumise ja Apollo Föderatsiooni vahel

Kuigi skeemi sidumine on GraphQL Föderatsiooni jaoks elujõuline valik, on Apollo Föderatsioon muutunud populaarsemaks tänu oma täiustatud funktsioonidele ja paremale arendajakogemusele. Siin on kahe lähenemise võrdlus:

Omadus	Skeemi sidumine	Apollo Föderatsioon
Skeemi määratlus	Kasutab olemasolevat GraphQL skeemikeelt	Kasutab deklaratiivset skeemikeelt koos direktiividega
Päringu planeerimine	Nõuab käsitsi päringu delegeerimist	Automaatne päringu planeerimine Apollo lüüsi poolt
Tüübilaiendused	Piiratud tugi	Sisseehitatud tugi tüübilaiendustele
Võtmedirektiivid	Ei toetata	Kasutab @key direktiivi olemite tuvastamiseks
Hajutatud jälgimine	Nõuab käsitsi rakendamist	Sisseehitatud tugi hajutatud jälgimisele
Tööriistad ja ökosüsteem	Vähem küpsed tööriistad	Küpsamad tööriistad ja suur kogukond
Keerukus	Võib suurtes süsteemides olla keeruline hallata	Loodud suurte ja keerukate süsteemide jaoks

Millal valida skeemi sidumine:

• Teil on olemasolevad GraphQL teenused ja soovite neid kiiresti kombineerida.
• Vajate lihtsat föderatsioonilahendust ja ei vaja täiustatud funktsioone.
• Teil on piiratud ressursid ja soovite vältida Apollo Föderatsiooni seadistamisega kaasnevat lisakulu.

Millal valida Apollo Föderatsioon:

• Ehitad suurt ja keerukat süsteemi mitme meeskonna ja teenusega.
• Vajate täiustatud funktsioone nagu tüübilaiendused, võtmedirektiivid ja hajutatud jälgimine.
• Soovite robustsemat ja skaleeritavamat föderatsioonilahendust.
• Eelistate deklaratiivsemat ja automatiseeritumat lähenemist föderatsioonile.

Reaalse maailma näited ja kasutusjuhud

Siin on mõned reaalse maailma näited, kuidas GraphQL Föderatsiooni, sealhulgas skeemi sidumist, saab kasutada:

• E-kaubanduse platvorm: E-kaubanduse platvorm võib kasutada GraphQL Föderatsiooni, et kombineerida andmeid mitmest teenusest, näiteks tootekataloogi teenusest, kasutajateenusest, tellimuste teenusest ja makseteenusest. See võimaldab klientidel hõlpsasti hankida kogu teabe, mida nad vajavad tooteandmete, kasutajaprofiilide, tellimuste ajaloo ja makseteabe kuvamiseks.
• Sotsiaalmeedia platvorm: Sotsiaalmeedia platvorm võiks kasutada GraphQL Föderatsiooni, et kombineerida andmeid teenustest, mis haldavad kasutajaprofiile, postitusi, kommentaare ja meeldimisi. See võimaldab klientidel tõhusalt hankida kogu teabe, mis on vajalik kasutaja profiili, tema postituste ning nendega seotud kommentaaride ja meeldimiste kuvamiseks.
• Finantsteenuste rakendus: Finantsteenuste rakendus võib kasutada GraphQL Föderatsiooni, et kombineerida andmeid teenustest, mis haldavad kontosid, tehinguid ja investeeringuid. See võimaldab klientidel hõlpsasti hankida kogu teabe, mida nad vajavad kontojääkide, tehingute ajaloo ja investeerimisportfellide kuvamiseks.
• Sisuhaldussüsteem (CMS): CMS saab kasutada GraphQL Föderatsiooni, et integreerida andmeid erinevatest allikatest, nagu artiklid, pildid, videod ja kasutajate loodud sisu. See võimaldab ühtset API-d, et hankida kogu sisu, mis on seotud konkreetse teema või autoriga.
• Tervishoiurakendus: Integreerige patsiendiandmeid erinevatest süsteemidest, nagu elektroonilised tervisekaardid (EHR), laboritulemused ja vastuvõtuaegade broneerimine. See pakub arstidele ühtse juurdepääsupunkti põhjalikule patsiendiinfole.

Skeemi sidumise parimad tavad

Skeemi sidumise eduka rakendamise tagamiseks järgige neid parimaid tavasid:

• Planeerige oma skeem hoolikalt: Enne skeemide kokku sidumise alustamist planeerige hoolikalt ühtse skeemi struktuur. See hõlmab tüüpide vaheliste seoste määratlemist erinevates skeemides, tüüpide ja väljade ümbernimetamist konfliktide vältimiseks ning üldiste andmetele juurdepääsu mustrite arvesse võtmist.
• Kasutage järjepidevaid nimetamiskonventsioone: Võtke kasutusele järjepidevad nimetamiskonventsioonid tüüpidele, väljadele ja toimingutele kõigis teenustes. See aitab vältida konflikte ja muudab ühtse skeemi mõistmise lihtsamaks.
• Dokumenteerige oma skeem: Dokumenteerige ühtne skeem põhjalikult, sealhulgas tüüpide, väljade ja toimingute kirjeldused. See muudab arendajatele skeemi mõistmise ja kasutamise lihtsamaks.
• Jälgige jõudlust: Jälgige lüüsi ja kaugteenuste jõudlust, et tuvastada ja lahendada kõik jõudluse kitsaskohad. Kasutage tööriistu nagu hajutatud jälgimine, et jälgida päringuid mitmes teenuses.
• Rakendage turvalisust: Rakendage asjakohaseid turvameetmeid, et kaitsta lüüsi ja kaugteenuseid volitamata juurdepääsu eest. See võib hõlmata autentimis- ja autoriseerimismehhanismide kasutamist, samuti sisendi valideerimist ja väljundi kodeerimist.
• Versioneerige oma skeemi: Skeemide arendamisel versioneerige neid asjakohaselt, et tagada klientidele võimalus jätkata skeemi vanemate versioonide kasutamist ilma katkestusteta. See aitab vältida rikkumisi ja tagada tagasiühilduvuse.
• Automatiseerige kasutuselevõtt: Automatiseerige lüüsi ja kaugteenuste kasutuselevõtt, et tagada muudatuste kiire ja usaldusväärne rakendamine. See aitab vähendada vigade riski ja parandada süsteemi üldist paindlikkust.

Kokkuvõte

GraphQL Föderatsioon koos skeemi sidumisega pakub võimsat lähenemist ühtsete API-de loomiseks mitmest teenusest mikroteenuste arhitektuuris. Mõistes selle põhikontseptsioone, eeliseid, piiranguid ja rakendustehnikaid, saate kasutada skeemi sidumist andmetele juurdepääsu lihtsustamiseks, skaleeritavuse parandamiseks ja hooldatavuse suurendamiseks. Kuigi Apollo Föderatsioon on kujunenud arenenumaks lahenduseks, jääb skeemi sidumine elujõuliseks valikuks lihtsamate stsenaariumide korral või olemasolevate GraphQL teenuste integreerimisel. Kaaluge hoolikalt oma konkreetseid vajadusi ja nõudeid, et valida oma organisatsiooni jaoks parim lähenemine.